﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using UnityEngine;

public static class CoroutineExtension
{
    [CompilerGenerated]
    private static Func<float> <>f__am$cache0;
    [CompilerGenerated]
    private static Func<Rect, Rect, float, Rect> <>f__am$cache1;
    [CompilerGenerated]
    private static Func<float, float, float, float> <>f__am$cache10;
    [CompilerGenerated]
    private static Func<float> <>f__am$cache2;
    [CompilerGenerated]
    private static Func<Color, Color, float, Color> <>f__am$cache3;
    [CompilerGenerated]
    private static Func<float> <>f__am$cache4;
    [CompilerGenerated]
    private static Func<Vector3, Vector3, float, Vector3> <>f__am$cache5;
    [CompilerGenerated]
    private static Func<float> <>f__am$cache6;
    [CompilerGenerated]
    private static Func<Vector3, Vector3, float, Vector3> <>f__am$cache7;
    [CompilerGenerated]
    private static Func<float> <>f__am$cache8;
    [CompilerGenerated]
    private static Func<Vector3, Vector3, float, Vector3> <>f__am$cache9;
    [CompilerGenerated]
    private static Func<float> <>f__am$cacheA;
    [CompilerGenerated]
    private static Func<int, int, float, int> <>f__am$cacheB;
    [CompilerGenerated]
    private static Func<float, float, float, float> <>f__am$cacheC;
    [CompilerGenerated]
    private static Func<float> <>f__am$cacheD;
    [CompilerGenerated]
    private static Func<float, float, float, float> <>f__am$cacheE;
    [CompilerGenerated]
    private static Func<float> <>f__am$cacheF;

    [DebuggerHidden]
    private static IEnumerator AnimateValue<T>(Func<T> startValue, Func<T> endValue, float duration, Func<float> deltaTime, Func<T, T, float, T> lerpMethod, AnimationCurve curve, Action<T> onGetValue, Action onFinished = null)
    {
        return new <AnimateValue>c__Iterator26<T> { lerpMethod = lerpMethod, onGetValue = onGetValue, deltaTime = deltaTime, startValue = startValue, endValue = endValue, duration = duration, curve = curve, onFinished = onFinished, <$>lerpMethod = lerpMethod, <$>onGetValue = onGetValue, <$>deltaTime = deltaTime, <$>startValue = startValue, <$>endValue = endValue, <$>duration = duration, <$>curve = curve, <$>onFinished = onFinished };
    }

    private static Coroutine CheckAndStartCoroutine(this MonoBehaviour starter, IEnumerator routine)
    {
        if ((starter != null) && starter.gameObject.activeInHierarchy)
        {
            return starter.StartCoroutine(routine);
        }
        return null;
    }

    [DebuggerHidden]
    private static IEnumerator LateUpdate(Action action)
    {
        return new <LateUpdate>c__Iterator1E { action = action, <$>action = action };
    }

    [DebuggerHidden]
    private static IEnumerator PlayAndWaitForStateEnd(Animator animator, int stateHash, Action onFinished)
    {
        return new <PlayAndWaitForStateEnd>c__Iterator1F { animator = animator, stateHash = stateHash, onFinished = onFinished, <$>animator = animator, <$>stateHash = stateHash, <$>onFinished = onFinished };
    }

    public static Coroutine Start(this IEnumerator routine, MonoBehaviour handler)
    {
        if ((routine != null) && (handler != null))
        {
            return handler.StartCoroutine(routine);
        }
        return null;
    }

    public static Coroutine StartAnimateColor(this MonoBehaviour starter, Color startValue, Color endValue, float duration, Action<Color> onGetValue, Action onFinished = null)
    {
        <StartAnimateColor>c__AnonStorey81 storey = new <StartAnimateColor>c__AnonStorey81 {
            startValue = startValue,
            endValue = endValue
        };
        if (<>f__am$cache2 == null)
        {
            <>f__am$cache2 = () => Time.deltaTime;
        }
        if (<>f__am$cache3 == null)
        {
            <>f__am$cache3 = (s, e, t) => Color.Lerp(s, e, t);
        }
        return starter.CheckAndStartCoroutine(AnimateValue<Color>(new Func<Color>(storey.<>m__167), new Func<Color>(storey.<>m__168), duration, <>f__am$cache2, <>f__am$cache3, AnimationCurve.Linear(0f, 0f, 1f, 1f), onGetValue, onFinished));
    }

    public static Coroutine StartAnimateFloat(this MonoBehaviour starter, float startValue, float endValue, float duration, Action<float> onGetValue, Action onFinished = null)
    {
        <StartAnimateFloat>c__AnonStorey87 storey = new <StartAnimateFloat>c__AnonStorey87 {
            startValue = startValue,
            endValue = endValue
        };
        if (<>f__am$cacheD == null)
        {
            <>f__am$cacheD = () => Time.deltaTime;
        }
        if (<>f__am$cacheE == null)
        {
            <>f__am$cacheE = (s, e, t) => Mathf.Lerp(s, e, t);
        }
        return starter.CheckAndStartCoroutine(AnimateValue<float>(new Func<float>(storey.<>m__17D), new Func<float>(storey.<>m__17E), duration, <>f__am$cacheD, <>f__am$cacheE, AnimationCurve.Linear(0f, 0f, 1f, 1f), onGetValue, onFinished));
    }

    public static Coroutine StartAnimateFloat(this MonoBehaviour starter, float startValue, float endValue, float duration, Func<float> getDeltaTime, Action<float> onGetValue, Action onFinished = null)
    {
        <StartAnimateFloat>c__AnonStorey86 storey = new <StartAnimateFloat>c__AnonStorey86 {
            startValue = startValue,
            endValue = endValue
        };
        if (<>f__am$cacheC == null)
        {
            <>f__am$cacheC = (s, e, t) => Mathf.Lerp(s, e, t);
        }
        return starter.CheckAndStartCoroutine(AnimateValue<float>(new Func<float>(storey.<>m__17A), new Func<float>(storey.<>m__17B), duration, getDeltaTime, <>f__am$cacheC, AnimationCurve.Linear(0f, 0f, 1f, 1f), onGetValue, onFinished));
    }

    public static Coroutine StartAnimateFloat(this MonoBehaviour starter, float startValue, float endValue, float duration, AnimationCurve curve, Action<float> onGetValue, Action onFinished = null)
    {
        <StartAnimateFloat>c__AnonStorey88 storey = new <StartAnimateFloat>c__AnonStorey88 {
            startValue = startValue,
            endValue = endValue
        };
        if (<>f__am$cacheF == null)
        {
            <>f__am$cacheF = () => Time.deltaTime;
        }
        if (<>f__am$cache10 == null)
        {
            <>f__am$cache10 = (s, e, t) => Mathf.Lerp(s, e, t);
        }
        return starter.CheckAndStartCoroutine(AnimateValue<float>(new Func<float>(storey.<>m__181), new Func<float>(storey.<>m__182), duration, <>f__am$cacheF, <>f__am$cache10, curve, onGetValue, onFinished));
    }

    public static Coroutine StartAnimateInt(this MonoBehaviour starter, int startValue, int endValue, float duration, Action<int> onGetValue, Action onFinished = null)
    {
        <StartAnimateInt>c__AnonStorey85 storey = new <StartAnimateInt>c__AnonStorey85 {
            startValue = startValue,
            endValue = endValue
        };
        if (<>f__am$cacheA == null)
        {
            <>f__am$cacheA = () => Time.deltaTime;
        }
        if (<>f__am$cacheB == null)
        {
            <>f__am$cacheB = (s, e, t) => Mathf.RoundToInt(Mathf.Lerp((float) s, (float) e, t));
        }
        return starter.CheckAndStartCoroutine(AnimateValue<int>(new Func<int>(storey.<>m__176), new Func<int>(storey.<>m__177), duration, <>f__am$cacheA, <>f__am$cacheB, AnimationCurve.Linear(0f, 0f, 1f, 1f), onGetValue, onFinished));
    }

    public static Coroutine StartAnimateRect(this MonoBehaviour starter, Rect startValue, Rect endValue, float duration, Action<Rect> onGetValue, Action onFinished = null)
    {
        <StartAnimateRect>c__AnonStorey80 storey = new <StartAnimateRect>c__AnonStorey80 {
            startValue = startValue,
            endValue = endValue
        };
        if (<>f__am$cache0 == null)
        {
            <>f__am$cache0 = () => Time.deltaTime;
        }
        if (<>f__am$cache1 == null)
        {
            <>f__am$cache1 = (s, e, t) => s.Lerp(e, t);
        }
        return starter.CheckAndStartCoroutine(AnimateValue<Rect>(new Func<Rect>(storey.<>m__163), new Func<Rect>(storey.<>m__164), duration, <>f__am$cache0, <>f__am$cache1, AnimationCurve.Linear(0f, 0f, 1f, 1f), onGetValue, onFinished));
    }

    public static Coroutine StartAnimateVector3(this MonoBehaviour starter, Vector3 startValue, Func<Vector3> endValueGetter, float duration, Action<Vector3> onGetValue, Action onFinished = null)
    {
        <StartAnimateVector3>c__AnonStorey82 storey = new <StartAnimateVector3>c__AnonStorey82 {
            startValue = startValue
        };
        if (<>f__am$cache4 == null)
        {
            <>f__am$cache4 = () => Time.deltaTime;
        }
        if (<>f__am$cache5 == null)
        {
            <>f__am$cache5 = (s, e, t) => Vector3.Lerp(s, e, t);
        }
        return starter.CheckAndStartCoroutine(AnimateValue<Vector3>(new Func<Vector3>(storey.<>m__16B), endValueGetter, duration, <>f__am$cache4, <>f__am$cache5, AnimationCurve.Linear(0f, 0f, 1f, 1f), onGetValue, onFinished));
    }

    public static Coroutine StartAnimateVector3(this MonoBehaviour starter, Vector3 startValue, Vector3 endValue, float duration, Action<Vector3> onGetValue, Action onFinished = null)
    {
        <StartAnimateVector3>c__AnonStorey83 storey = new <StartAnimateVector3>c__AnonStorey83 {
            startValue = startValue,
            endValue = endValue
        };
        if (<>f__am$cache6 == null)
        {
            <>f__am$cache6 = () => Time.deltaTime;
        }
        if (<>f__am$cache7 == null)
        {
            <>f__am$cache7 = (s, e, t) => Vector3.Lerp(s, e, t);
        }
        return starter.CheckAndStartCoroutine(AnimateValue<Vector3>(new Func<Vector3>(storey.<>m__16E), new Func<Vector3>(storey.<>m__16F), duration, <>f__am$cache6, <>f__am$cache7, AnimationCurve.Linear(0f, 0f, 1f, 1f), onGetValue, onFinished));
    }

    public static Coroutine StartAnimateVector3(this MonoBehaviour starter, Vector3 startValue, Vector3 endValue, float duration, AnimationCurve curve, Action<Vector3> onGetValue, Action onFinished = null)
    {
        <StartAnimateVector3>c__AnonStorey84 storey = new <StartAnimateVector3>c__AnonStorey84 {
            startValue = startValue,
            endValue = endValue
        };
        if (<>f__am$cache8 == null)
        {
            <>f__am$cache8 = () => Time.deltaTime;
        }
        if (<>f__am$cache9 == null)
        {
            <>f__am$cache9 = (s, e, t) => Vector3.Lerp(s, e, t);
        }
        return starter.CheckAndStartCoroutine(AnimateValue<Vector3>(new Func<Vector3>(storey.<>m__172), new Func<Vector3>(storey.<>m__173), duration, <>f__am$cache8, <>f__am$cache9, curve, onGetValue, onFinished));
    }

    public static Coroutine StartLateUpdate(this MonoBehaviour handler, Action action)
    {
        return handler.CheckAndStartCoroutine(LateUpdate(action));
    }

    public static Coroutine StartPlayAnimationAndWaitForEnd(this MonoBehaviour handler, Animator animator, int stateHash, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(PlayAndWaitForStateEnd(animator, stateHash, onFinished));
    }

    public static Coroutine StartPlayAnimationAndWaitForEnd(this MonoBehaviour handler, Animator animator, string stateName, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(PlayAndWaitForStateEnd(animator, Animator.StringToHash(stateName), onFinished));
    }

    public static Coroutine StartTypingEffect(this MonoBehaviour handler, string text, Action<string> resultGetter, Func<float> typingSpeedSetter, Action onFinisthed = null)
    {
        return handler.CheckAndStartCoroutine(TypingEffect(text, resultGetter, typingSpeedSetter, onFinisthed));
    }

    public static Coroutine StartUpdate(this MonoBehaviour handler, Action action)
    {
        return handler.CheckAndStartCoroutine(Update(action));
    }

    public static Coroutine StartWaitForCoroutine(this MonoBehaviour handler, IEnumerator routine, Action onFinished)
    {
        return handler.CheckAndStartCoroutine(WaitForCoroutine(handler, routine, onFinished));
    }

    public static Coroutine StartWaitForCoroutine<T>(this MonoBehaviour handler, Func<T> coroutineGetter, Action onFinished = null) where T: YieldInstruction
    {
        return handler.CheckAndStartCoroutine(WaitForCoroutine<T>(coroutineGetter, onFinished));
    }

    public static Coroutine StartWaitForCoroutines<T>(this MonoBehaviour handler, params Func<T>[] coroutineGetters) where T: YieldInstruction
    {
        return handler.CheckAndStartCoroutine(WaitForCoroutines<T>(coroutineGetters, null));
    }

    public static Coroutine StartWaitForCoroutines(this MonoBehaviour handler, IEnumerator[] coroutines, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(WaitForCoroutines(handler, coroutines, onFinished));
    }

    public static Coroutine StartWaitForCoroutines<T>(this MonoBehaviour handler, Func<T>[] coroutineGetters, Action onFinished = null) where T: YieldInstruction
    {
        return handler.CheckAndStartCoroutine(WaitForCoroutines<T>(coroutineGetters, onFinished));
    }

    public static Coroutine StartWaitForEndOfFrame(this MonoBehaviour handler, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(WaitForEndOfFrame(onFinished));
    }

    public static Coroutine StartWaitForFixedUpdate(this MonoBehaviour handler, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(WaitForFixedUpdate(onFinished));
    }

    public static Coroutine StartWaitForFrames(this MonoBehaviour handler, int frameCount, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(WaitForFrames(frameCount, onFinished));
    }

    public static Coroutine StartWaitForSeconds(this MonoBehaviour handler, float time, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(WaitForSeconds(time, false, onFinished));
    }

    public static Coroutine StartWaitForSecondsUnscaled(this MonoBehaviour handler, float time, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(WaitForSeconds(time, true, onFinished));
    }

    public static Coroutine StartWaitForWWW(this MonoBehaviour handler, WWW www, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(WaitForWWW(www, onFinished));
    }

    public static Coroutine StartWaitUntil(this MonoBehaviour handler, Func<bool> predicate, Action onFinished = null)
    {
        return handler.CheckAndStartCoroutine(WaitFor(predicate, onFinished));
    }

    public static void Stop(this Coroutine coroutine, MonoBehaviour handler)
    {
        if ((coroutine != null) && (handler != null))
        {
            handler.StopCoroutine(coroutine);
        }
    }

    [DebuggerHidden]
    private static IEnumerator TypingEffect(string text, Action<string> resultGetter, Func<float> typingSpeedSetter, Action onFinisthed = null)
    {
        return new <TypingEffect>c__Iterator25 { resultGetter = resultGetter, typingSpeedSetter = typingSpeedSetter, text = text, onFinisthed = onFinisthed, <$>resultGetter = resultGetter, <$>typingSpeedSetter = typingSpeedSetter, <$>text = text, <$>onFinisthed = onFinisthed };
    }

    [DebuggerHidden]
    private static IEnumerator Update(Action action)
    {
        return new <Update>c__Iterator1D { action = action, <$>action = action };
    }

    [DebuggerHidden]
    private static IEnumerator WaitFor(Func<bool> gotoFinishedIfTrue, Action onFinished)
    {
        return new <WaitFor>c__Iterator18 { gotoFinishedIfTrue = gotoFinishedIfTrue, onFinished = onFinished, <$>gotoFinishedIfTrue = gotoFinishedIfTrue, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForCoroutine<T>(Func<T> coroutineGetter, Action onFinished) where T: YieldInstruction
    {
        return new <WaitForCoroutine>c__Iterator23<T> { coroutineGetter = coroutineGetter, onFinished = onFinished, <$>coroutineGetter = coroutineGetter, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForCoroutine(MonoBehaviour handler, IEnumerator routine, Action onFinished)
    {
        return new <WaitForCoroutine>c__Iterator21 { handler = handler, routine = routine, onFinished = onFinished, <$>handler = handler, <$>routine = routine, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForCoroutines<T>(Func<T>[] coroutineGetters, Action onFinished) where T: YieldInstruction
    {
        return new <WaitForCoroutines>c__Iterator24<T> { coroutineGetters = coroutineGetters, onFinished = onFinished, <$>coroutineGetters = coroutineGetters, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForCoroutines(MonoBehaviour handler, IEnumerator[] coroutines, Action onFinished)
    {
        return new <WaitForCoroutines>c__Iterator22 { coroutines = coroutines, handler = handler, onFinished = onFinished, <$>coroutines = coroutines, <$>handler = handler, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForEndOfFrame(Action onFinished)
    {
        return new <WaitForEndOfFrame>c__Iterator1B { onFinished = onFinished, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForFixedUpdate(Action onFinished)
    {
        return new <WaitForFixedUpdate>c__Iterator1C { onFinished = onFinished, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForFrames(int count, Action onFinished)
    {
        return new <WaitForFrames>c__Iterator20 { count = count, onFinished = onFinished, <$>count = count, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForSeconds(float time, bool unscaled, Action onFinished)
    {
        return new <WaitForSeconds>c__Iterator1A { time = time, unscaled = unscaled, onFinished = onFinished, <$>time = time, <$>unscaled = unscaled, <$>onFinished = onFinished };
    }

    [DebuggerHidden]
    private static IEnumerator WaitForWWW(WWW www, Action onFinished)
    {
        return new <WaitForWWW>c__Iterator19 { www = www, onFinished = onFinished, <$>www = www, <$>onFinished = onFinished };
    }

    [CompilerGenerated]
    private sealed class <AnimateValue>c__Iterator26<T> : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal AnimationCurve <$>curve;
        internal Func<float> <$>deltaTime;
        internal float <$>duration;
        internal Func<T> <$>endValue;
        internal Func<T, T, float, T> <$>lerpMethod;
        internal Action <$>onFinished;
        internal Action<T> <$>onGetValue;
        internal Func<T> <$>startValue;
        internal float <curEvaluate>__2;
        internal T <curValue>__1;
        internal float <timer>__0;
        internal AnimationCurve curve;
        internal Func<float> deltaTime;
        internal float duration;
        internal Func<T> endValue;
        internal Func<T, T, float, T> lerpMethod;
        internal Action onFinished;
        internal Action<T> onGetValue;
        internal Func<T> startValue;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    if ((((this.lerpMethod != null) && (this.onGetValue != null)) && ((this.deltaTime != null) && (this.startValue != null))) && (this.endValue != null))
                    {
                        this.duration = Mathf.Max(this.duration, 1E-05f);
                        this.<timer>__0 = 0f;
                        this.<curValue>__1 = this.startValue();
                        break;
                    }
                    goto Label_0149;

                case 1:
                    break;

                default:
                    goto Label_0149;
            }
            while (this.<timer>__0 <= this.duration)
            {
                this.<timer>__0 += this.deltaTime();
                this.<curEvaluate>__2 = this.curve.Evaluate(this.<timer>__0 / this.duration);
                this.<curValue>__1 = this.lerpMethod(this.startValue(), this.endValue(), this.<curEvaluate>__2);
                this.onGetValue(this.<curValue>__1);
                this.$current = null;
                this.$PC = 1;
                return true;
            }
            if (this.onFinished != null)
            {
                this.onFinished();
            }
            this.$PC = -1;
        Label_0149:
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <LateUpdate>c__Iterator1E : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Action <$>action;
        internal Action action;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    break;

                case 1:
                    if (this.action != null)
                    {
                        this.action();
                    }
                    break;

                default:
                    goto Label_005A;
            }
            this.$current = new WaitForEndOfFrame();
            this.$PC = 1;
            return true;
            this.$PC = -1;
        Label_005A:
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <PlayAndWaitForStateEnd>c__Iterator1F : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Animator <$>animator;
        internal Action <$>onFinished;
        internal int <$>stateHash;
        internal Animator animator;
        internal Action onFinished;
        internal int stateHash;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.animator.Play(this.stateHash, 0, 0f);
                    this.$current = null;
                    this.$PC = 1;
                    goto Label_00DA;

                case 1:
                    this.$current = null;
                    this.$PC = 2;
                    goto Label_00DA;

                case 2:
                case 3:
                    if ((this.animator.GetCurrentAnimatorStateInfo(0).shortNameHash == this.stateHash) && (this.animator.GetCurrentAnimatorStateInfo(0).normalizedTime < 1f))
                    {
                        this.$current = null;
                        this.$PC = 3;
                        goto Label_00DA;
                    }
                    if (this.onFinished != null)
                    {
                        this.onFinished();
                    }
                    this.$PC = -1;
                    break;
            }
            return false;
        Label_00DA:
            return true;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateColor>c__AnonStorey81
    {
        internal Color endValue;
        internal Color startValue;

        internal Color <>m__167()
        {
            return this.startValue;
        }

        internal Color <>m__168()
        {
            return this.endValue;
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateFloat>c__AnonStorey86
    {
        internal float endValue;
        internal float startValue;

        internal float <>m__17A()
        {
            return this.startValue;
        }

        internal float <>m__17B()
        {
            return this.endValue;
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateFloat>c__AnonStorey87
    {
        internal float endValue;
        internal float startValue;

        internal float <>m__17D()
        {
            return this.startValue;
        }

        internal float <>m__17E()
        {
            return this.endValue;
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateFloat>c__AnonStorey88
    {
        internal float endValue;
        internal float startValue;

        internal float <>m__181()
        {
            return this.startValue;
        }

        internal float <>m__182()
        {
            return this.endValue;
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateInt>c__AnonStorey85
    {
        internal int endValue;
        internal int startValue;

        internal int <>m__176()
        {
            return this.startValue;
        }

        internal int <>m__177()
        {
            return this.endValue;
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateRect>c__AnonStorey80
    {
        internal Rect endValue;
        internal Rect startValue;

        internal Rect <>m__163()
        {
            return this.startValue;
        }

        internal Rect <>m__164()
        {
            return this.endValue;
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateVector3>c__AnonStorey82
    {
        internal Vector3 startValue;

        internal Vector3 <>m__16B()
        {
            return this.startValue;
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateVector3>c__AnonStorey83
    {
        internal Vector3 endValue;
        internal Vector3 startValue;

        internal Vector3 <>m__16E()
        {
            return this.startValue;
        }

        internal Vector3 <>m__16F()
        {
            return this.endValue;
        }
    }

    [CompilerGenerated]
    private sealed class <StartAnimateVector3>c__AnonStorey84
    {
        internal Vector3 endValue;
        internal Vector3 startValue;

        internal Vector3 <>m__172()
        {
            return this.startValue;
        }

        internal Vector3 <>m__173()
        {
            return this.endValue;
        }
    }

    [CompilerGenerated]
    private sealed class <TypingEffect>c__Iterator25 : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Action <$>onFinisthed;
        internal Action<string> <$>resultGetter;
        internal string <$>text;
        internal Func<float> <$>typingSpeedSetter;
        internal float <timer>__1;
        internal float <typingEffectSpeed>__0;
        internal Action onFinisthed;
        internal Action<string> resultGetter;
        internal string text;
        internal Func<float> typingSpeedSetter;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    if (this.resultGetter != null)
                    {
                        this.<typingEffectSpeed>__0 = 10f;
                        this.<timer>__1 = 0f;
                        break;
                    }
                    goto Label_0100;

                case 1:
                    break;

                default:
                    goto Label_0100;
            }
            while (this.<timer>__1 <= 1f)
            {
                if (this.typingSpeedSetter != null)
                {
                    this.<typingEffectSpeed>__0 = Mathf.Max(this.typingSpeedSetter(), 0.001f);
                }
                this.<timer>__1 += Time.deltaTime / (((float) this.text.Length) / this.<typingEffectSpeed>__0);
                this.resultGetter(this.text.Lerp(0, this.text.Length, this.<timer>__1));
                this.$current = null;
                this.$PC = 1;
                return true;
            }
            if (this.onFinisthed != null)
            {
                this.onFinisthed();
            }
            this.$PC = -1;
        Label_0100:
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <Update>c__Iterator1D : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Action <$>action;
        internal Action action;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    break;

                case 1:
                    break;
                    this.$PC = -1;
                    goto Label_0056;

                default:
                    goto Label_0056;
            }
            if (this.action != null)
            {
                this.action();
            }
            this.$current = null;
            this.$PC = 1;
            return true;
        Label_0056:
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitFor>c__Iterator18 : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Func<bool> <$>gotoFinishedIfTrue;
        internal Action <$>onFinished;
        internal Func<bool> gotoFinishedIfTrue;
        internal Action onFinished;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                case 1:
                    if (!this.gotoFinishedIfTrue())
                    {
                        this.$current = null;
                        this.$PC = 1;
                        return true;
                    }
                    if (this.onFinished != null)
                    {
                        this.onFinished();
                    }
                    this.$PC = -1;
                    break;
            }
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForCoroutine>c__Iterator21 : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal MonoBehaviour <$>handler;
        internal Action <$>onFinished;
        internal IEnumerator <$>routine;
        internal MonoBehaviour handler;
        internal Action onFinished;
        internal IEnumerator routine;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.$current = this.handler.StartCoroutine(this.routine);
                    this.$PC = 1;
                    return true;

                case 1:
                    if (this.onFinished != null)
                    {
                        this.onFinished();
                    }
                    this.$PC = -1;
                    break;
            }
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForCoroutine>c__Iterator23<T> : IDisposable, IEnumerator, IEnumerator<object> where T: YieldInstruction
    {
        internal object $current;
        internal int $PC;
        internal Func<T> <$>coroutineGetter;
        internal Action <$>onFinished;
        internal Func<T> coroutineGetter;
        internal Action onFinished;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.$current = this.coroutineGetter();
                    this.$PC = 1;
                    return true;

                case 1:
                    if (this.onFinished != null)
                    {
                        this.onFinished();
                    }
                    this.$PC = -1;
                    break;
            }
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForCoroutines>c__Iterator22 : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal IEnumerator[] <$>coroutines;
        internal MonoBehaviour <$>handler;
        internal Action <$>onFinished;
        internal IEnumerator[] <$s_125>__0;
        internal int <$s_126>__1;
        internal IEnumerator <coroutine>__2;
        internal IEnumerator[] coroutines;
        internal MonoBehaviour handler;
        internal Action onFinished;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.<$s_125>__0 = this.coroutines;
                    this.<$s_126>__1 = 0;
                    break;

                case 1:
                    this.<$s_126>__1++;
                    break;

                default:
                    goto Label_00AD;
            }
            if (this.<$s_126>__1 < this.<$s_125>__0.Length)
            {
                this.<coroutine>__2 = this.<$s_125>__0[this.<$s_126>__1];
                this.$current = this.handler.StartCoroutine(this.<coroutine>__2);
                this.$PC = 1;
                return true;
            }
            if (this.onFinished != null)
            {
                this.onFinished();
            }
            this.$PC = -1;
        Label_00AD:
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForCoroutines>c__Iterator24<T> : IDisposable, IEnumerator, IEnumerator<object> where T: YieldInstruction
    {
        internal object $current;
        internal int $PC;
        internal Func<T>[] <$>coroutineGetters;
        internal Action <$>onFinished;
        internal Func<T>[] <$s_127>__0;
        internal int <$s_128>__1;
        internal Func<T> <coroutineGetter>__2;
        internal Func<T>[] coroutineGetters;
        internal Action onFinished;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.<$s_127>__0 = this.coroutineGetters;
                    this.<$s_128>__1 = 0;
                    break;

                case 1:
                    this.<$s_128>__1++;
                    break;

                default:
                    goto Label_00AC;
            }
            if (this.<$s_128>__1 < this.<$s_127>__0.Length)
            {
                this.<coroutineGetter>__2 = this.<$s_127>__0[this.<$s_128>__1];
                this.$current = this.<coroutineGetter>__2();
                this.$PC = 1;
                return true;
            }
            if (this.onFinished != null)
            {
                this.onFinished();
            }
            this.$PC = -1;
        Label_00AC:
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForEndOfFrame>c__Iterator1B : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Action <$>onFinished;
        internal Action onFinished;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.$current = new WaitForEndOfFrame();
                    this.$PC = 1;
                    return true;

                case 1:
                    if (this.onFinished != null)
                    {
                        this.onFinished();
                    }
                    this.$PC = -1;
                    break;
            }
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForFixedUpdate>c__Iterator1C : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Action <$>onFinished;
        internal Action onFinished;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.$current = new WaitForFixedUpdate();
                    this.$PC = 1;
                    return true;

                case 1:
                    if (this.onFinished != null)
                    {
                        this.onFinished();
                    }
                    this.$PC = -1;
                    break;
            }
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForFrames>c__Iterator20 : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal int <$>count;
        internal Action <$>onFinished;
        internal int <i>__0;
        internal int count;
        internal Action onFinished;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.<i>__0 = this.count;
                    break;

                case 1:
                    this.<i>__0--;
                    break;

                default:
                    goto Label_007C;
            }
            if (this.<i>__0 > 0)
            {
                this.$current = null;
                this.$PC = 1;
                return true;
            }
            if (this.onFinished != null)
            {
                this.onFinished();
            }
            this.$PC = -1;
        Label_007C:
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForSeconds>c__Iterator1A : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Action <$>onFinished;
        internal float <$>time;
        internal bool <$>unscaled;
        internal float <timer>__0;
        internal Action onFinished;
        internal float time;
        internal bool unscaled;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.<timer>__0 = this.time;
                    break;

                case 1:
                    break;

                default:
                    goto Label_0099;
            }
            if (this.<timer>__0 > 0f)
            {
                this.<timer>__0 -= !this.unscaled ? Time.deltaTime : Time.unscaledDeltaTime;
                this.$current = null;
                this.$PC = 1;
                return true;
            }
            if (this.onFinished != null)
            {
                this.onFinished();
            }
            this.$PC = -1;
        Label_0099:
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }

    [CompilerGenerated]
    private sealed class <WaitForWWW>c__Iterator19 : IDisposable, IEnumerator, IEnumerator<object>
    {
        internal object $current;
        internal int $PC;
        internal Action <$>onFinished;
        internal WWW <$>www;
        internal Action onFinished;
        internal WWW www;

        [DebuggerHidden]
        public void Dispose()
        {
            this.$PC = -1;
        }

        public bool MoveNext()
        {
            uint num = (uint) this.$PC;
            this.$PC = -1;
            switch (num)
            {
                case 0:
                    this.$current = this.www;
                    this.$PC = 1;
                    return true;

                case 1:
                    if (this.onFinished != null)
                    {
                        this.onFinished();
                    }
                    this.$PC = -1;
                    break;
            }
            return false;
        }

        [DebuggerHidden]
        public void Reset()
        {
            throw new NotSupportedException();
        }

        object IEnumerator<object>.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.$current;
            }
        }
    }
}

